/**
 * 给定1000个case，每个case4张牌，问能否算24，允许分数
 * 多case，无论如何用一个哈希做记忆化。对4张牌排个序。
 * 然后做一个全排列，对每个全排列去check一下能不能算出24。
 * 假设当前排列四张牌记作1234，则一共只有2大种模式：
 * 前面另外两个计算中缀表达式的均有重复，且太啰嗦。
 * 这里写了一个利用后缀表达式进行dfs与输出的代码
 * 深搜的状态是当前计算数pos，与状态栈Stack
 * 递归结束条件是 pos==4 and Stack.size()==1，此时栈内是计算结果，看是否为24即可
 * 一共两大类操作：
 * 1. 如果Stack中有2个元素以上，则可以取出末尾两个元素，进行4种运算之一
 * 2. 如果pos!=4，则可以将A[pos]入栈
 * 这种写法，计算任意个数均可。
 * 
 * 因为允许分数，所以写了一个有理数类。
 * 标程使用的是取模运算，或者直接用double。
 */
#include <bits/stdc++.h>
#include <bits/extc++.h>
using namespace std;

using llt = long long;
using vi = vector<int>;
using vll = vector<llt>;
using pii = pair<int, int>;
using pll = pair<llt, llt>;

struct _t{
    int fenzi;
    int fenmu;
    _t():fenzi(0),fenmu(1){}
    _t(int a, int b):fenzi(a),fenmu(b){
        if(b < 0) fenzi = -fenzi, fenmu = -fenmu;
        auto g = __gcd(abs(a), abs(b));
        fenzi /= g;
        fenmu /= g;
    }
    const _t operator + (const _t & r) const {
        return _t(fenzi * r.fenmu + fenmu * r.fenzi, fenmu * r.fenmu);
    }
    const _t operator - (const _t & r) const {
        return _t(fenzi * r.fenmu - fenmu * r.fenzi, fenmu * r.fenmu);
    }
    const _t operator * (const _t & r) const {
        return _t(fenzi * r.fenzi, fenmu * r.fenmu);
    }
    const _t operator / (const _t & r) const {
        return _t(fenzi * r.fenmu, fenmu * r.fenzi);
    }
    bool isOK() const {
        return 24 == fenzi and 1 == fenmu;
    }
    bool is0() const {
        return 0 == fenzi;
    }
    void disp() const {
        if(1 == fenmu) cout << fenzi;
        else cout << fenzi << " / " << fenmu;
    }
    string to_string() const {
        if(1 == fenmu) return std::to_string(fenzi);
        return std::to_string(fenzi) + " / " + std::to_string(fenmu);
    }
};

using fun_t = function<_t(const _t &, const _t &)>;
fun_t F[4] = {
    [](const _t & a, const _t & b){return a + b;},
    [](const _t & a, const _t & b){return a - b;},
    [](const _t & a, const _t & b){return a * b;},
    [](const _t & a, const _t & b){return a / b;},
};
const string S = "+-*/";

array<int, 4> A;
unordered_map<array<int, 4>, int, function<size_t(const array<int, 4> &)>, function<bool(const array<int, 4> &, const array<int, 4> &)>> Map(
    100,
    [](const array<int, 4> & a)->size_t{return (((a[0] * 1331 + a[1]) * 13313) + a[2]) * 13313 + a[3];},
    [](const array<int, 4> & a, const array<int, 4> & b)->bool{return a[0] == b[0] and a[1] == b[1] and a[2] == b[2] and a[3] == b[3];}
);


vector<_t> Stack;
vector<string> Record;

bool dfs(int pos){
    if(pos == 4){
        if(1 == Stack.size()){
#ifndef ONLINE_JUDGE
        for(const auto & s : Record) cout << s << " "; 
        cout << "= ";
        Stack[0].disp();
        cout << endl; 
#endif

            return Stack[0].isOK();
        }
    }

    if(Stack.size() >= 2){
        auto b = Stack.back(); Stack.pop_back();
        auto a = Stack.back(); Stack.pop_back();
        for(int i=0;i<4;++i){
            if(3 == i and b.is0()) continue;

            Record.emplace_back(S.substr(i, 1));
            Stack.push_back(F[i](a, b));
            bool flag = dfs(pos);
            Stack.pop_back();
            Record.pop_back();
            if(flag) {
                Stack.emplace_back(a);
                Stack.emplace_back(b);                
                return true;
            }
        }
        Stack.emplace_back(a);
        Stack.emplace_back(b);
    }

    if(pos < 4){
        Record.emplace_back(_t{A[pos], 1}.to_string());
        Stack.push_back({A[pos], 1});
        bool flag = dfs(pos + 1);
        Stack.pop_back();
        Record.pop_back();
        if(flag) return true;
    }

    return false;
}

bool check(){
#ifndef ONLINE_JUDGE
    for(const auto & i : A) cout << i << " "; cout << endl;
#endif
    Stack.clear();
    bool flag = dfs(0);
    assert(Stack.empty());
    return flag;    
}


bool proc(){
    auto it = Map.find(A);
    if(it != Map.end()) return it->second;

    do{
        if(check()){
            Map.insert(it, {A, 1});
            return true;
        }
    }while(next_permutation(A.begin(), A.end()));
    Map.insert(it, {A, 0});
    return false;
}

int TR[256] = {0};

void work(){
    for(auto & i : A) {
        string s; cin >> s;
        if(s.length() == 1) i = TR[s[0]];
        else i = 10;
    }
    sort(A.begin(), A.end());
    cout << (proc() ? "YES\n" : "NO\n");
    return;
}


int main(){
#ifndef ONLINE_JUDGE
    freopen("z.txt", "r", stdin);
#endif
    ios::sync_with_stdio(0); cin.tie(0); cout.tie(0);	
    for(int c='0';c<='9';++c)TR[c] = c - '0';
    TR['A'] = 1;
    TR['K'] = 13;
    TR['Q'] = 12;
    TR['J'] = 11;
    
    int nofkase = 1;
	cin >> nofkase;
	while(nofkase--) work();
	return 0;
}